#!/usr/bin/python
# -*- coding: utf-8 -*-

##
# Módulos del sistema
try:
    import sys
    import os
    import time
except ImportError, error:
    print error
    print "Problemas al cargar los  módulos del sistema"

try:
    import BeautifulSoup
except ImportError, error:
    print error
    print "Problemas al cargar BeautifulSoup.\nVer LEEME.txt "

##
# Módulos definidos por nosotros
try:
    from DocumentoLatex import DocumentoLatex
    from caracteres_html import caracteres_html
    from EstiloCSS import EstiloCSS
    from config import archivo_log
except ImportError, error:
    print error
    print "Problemas al cargar los módulos del programa"

class HTMLParser:
    def __init__(self, seccion=None):
        self.documento_latex = DocumentoLatex(seccion)
        self.archivo_html = self.documento_latex.libro["home"]
        self.html_parseado = []
        self.estilos_css = []
        self.caracteres_html = caracteres_html
        self.loguear("---------------------------------")
        self.loguear(time.ctime())
        self.loguear("---------------------------------")
        self.titulo_imagen = ""

    def crear_sopa(self):
        try:
            print self.archivo_html
            html_open = open(self.archivo_html, "r")
        except IOError:
            print "El archivo no existe"
            #sys.exit(1)
            return False
        else:
            html_read = html_open.read()
            html_open.close()
            html_read = self.reemplazar_caracteres_html(html_read)
            self.soup = BeautifulSoup.BeautifulSoup(html_read)
            self.documento_latex.encoding = self.soup.originalEncoding
            return True

    def reemplazar_caracteres_html(self, html_read):
        for k, v in caracteres_html.iteritems():
            html_read = html_read.replace(k, v)
        return html_read

    def buscar_siguiente(self):
        path = self.documento_latex.libro["siguiente"]
        # IMPORTANTE: para TurboGears y PythonProgramming dejar la linea
        # inmediata de abajo
        self.archivo_html = path + self.soup.findAll(dict(a=True))[1].get("href")
        # IMPORTANTE: para PythonCookBook dejar la linea inmediata de abajo
        #self.archivo_html = path + self.soup.findAll(dict(a=True))[2].get("href")
        if self.archivo_html == self.documento_latex.libro["ultimo"]:
            self.documento_latex.finalizar()

    def buscar_siguiente_html(self):
        path = self.documento_latex.libro["siguiente"]
        links  = self.soup.findAll(dict(a=True, link=True))
        for link in links:
            if link.string in ["Next", "next"]:
                self.archivo_html = path + link.get("href")
                break
            elif link.get("rel") in ["Next", "next"]:
                self.archivo_html = path + link.get("href")
                break
        if self.archivo_html == self.documento_latex.libro["ultimo"]:
            self.documento_latex.finalizar()

    def transformar_enfasis(self, hijo):
        #if type(hijo) == BeautifulSoup.NavigableString:
            #return
        #if type(hijo) == BeautifulSoup.Comment:
            #return
        #if type(hijo) == BeautifulSoup.ProcessingInstruction:
            #return
        try:
            if hijo.parent.name in ["pre"]:
                aux = hijo.string
                hijo.replaceWith("%s " % aux)
            elif hijo.string == None:
                hijo.replaceWith("")
            # reemplazamos por negrita
            elif hijo.name in self.documento_latex.libro["negrita"]:
                aux = hijo.string.replace("\\", "\\\\")
                hijo.replaceWith("\\textbf{%s} " % aux)
            # reemplazamos por cursiva
            elif hijo.name in self.documento_latex.libro["cursiva"]:
                aux = hijo.string.replace("\\", "\\\\")
                hijo.replaceWith("\\textit{%s} " % aux)
            # reemplazamos por subindice o superindice
            elif hijo.name in self.documento_latex.libro["indice"]:
                aux = hijo.string.replace("\\", "\\\\")
                hijo.replaceWith("%s " % aux)
        except AttributeError:
            #print "WARNING: Intentando acceder a un atributo que no se posee"
            pass

    def parser_html(self):
        etiquetas = self.documento_latex.libro["etiquetas"]
        vineta = False
        for etiqueta in self.soup.findAll(etiquetas):
            try:
                if etiqueta.parent.parent.name in ["ul"] and not vineta:
                    self.documento_latex.abrir_vineta()
                    vineta = True
            except AttributeError:
                print "No tiene parent.parent"
                pass
            if etiqueta.findChild(dict(p=True)) != None:
                continue
            if etiqueta.parent != None and etiqueta.parent.name in ["li"]:
                self.transformar_enfasis(etiqueta)
                try:
                    texto = ''.join(etiqueta.contents)
                except TypeError:
                    pass
                self.documento_latex.vineta(texto)
                continue
            for hijo in etiqueta.recursiveChildGenerator():
                if type(hijo) == BeautifulSoup.NavigableString:
                    continue
                self.transformar_enfasis(hijo)
            if vineta:
                self.documento_latex.cerrar_vineta()
                vineta = False
            try:
                texto = ''.join(etiqueta.contents)
                #texto = etiqueta.renderContents()
            except TypeError:
                texto = []
                for contenido in etiqueta.contents:
                    try:
                        texto.append(contenido.string)
                    except AttributeError:
                        pass
                #print etiqueta.contents
                texto = ''.join(texto)
                print texto
                #continue
            estilo = etiqueta.name
            #pdb.set_trace()
            #if estilo in ["p"] and hijo.parent.name in ["li"]:
                #texto = ''.join(etiqueta.contents)
                #self.documento_latex.vineta(texto)
            #else:
            estilo = EstiloCSS(texto, estilo)
            self.documento_latex.escribir(estilo)

    def parser_css(self):
        etiquetas = self.documento_latex.libro["etiquetas"]
        vineta = False
        # buscamos todas las etiquetas que nos interesan
        for etiqueta in self.soup.findAll(etiquetas):
            # ingresamos la imagen
            if etiqueta.name in ["img"]:
                try:
                    self.titulo_imagen = self.titulo_imagen.split(". ")[1]
                except IndexError:
                    pass
                src_imagen = etiqueta.get("src")
                src_imagen_name = os.path.split(src_imagen)[1]
                if src_imagen_name in os.listdir(self.documento_latex.libro["imagenes"]):
                    path_imagen = os.path.join(self.documento_latex.libro["siguiente"], src_imagen)
                    gif = path_imagen
                    eps = path_imagen.replace(".gif", ".eps")
                    os.system("sam2p %s EPS: %s" % (gif, eps))
                    aux = "\\begin{figure}[ht]\n\\centering\n\\includegraphics[width=%spx, height=%spx]{%s}\n\\caption{{\small %s}}\n\\end{figure}" % (etiqueta.get("width"), etiqueta.get("height"), eps, self.titulo_imagen)
                    self.documento_latex.texto(aux)
            # recorremos TODAS las etiquetas que tenga dentro (hijos) la
            # etiqueta actual para transformar la negrita y cursiva
            for hijo in etiqueta.recursiveChildGenerator():
                self.transformar_enfasis(hijo)
            estilo = None
            if etiqueta.has_key("class"):
                estilo = etiqueta.get("class")
                if estilo == "docList" and not vineta:
                    self.documento_latex.abrir_vineta()
                    vineta = True
                elif estilo != "docList" and vineta:
                    self.documento_latex.cerrar_vineta()
                    vineta = False
                elif estilo == "docFigureTitle":
                    self.titulo_imagen = etiqueta.string
                    continue
            # habia p que no tenian clases y su contenido era vacio
            # por lo que los descartamos y continuamos
            elif etiqueta.name in ["p"]:
                continue
            elif etiqueta.name in ["pre"]:
                estilo = "pre"
            try:
                texto = ''.join(etiqueta.contents)
            except TypeError:
                pass
                #print etiqueta.contents
            if estilo == None:
                self.loguear(self.archivo_html)
                self.loguear("WARNING: Estilo igual a None")
                self.loguear(etiqueta.toEncoding(etiqueta))
                continue
            estilo = EstiloCSS(texto, estilo)
            self.documento_latex.escribir(estilo)
        if vineta:
            self.documento_latex.cerrar_vineta()

    def loguear(self, texto):
        log = open(archivo_log, "a")
        texto = texto.encode()
        log.write(texto+"\n")
        log.close()

    def finalizar(self):
        self.documento_latex.finalizar()
